home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / misc / volume24 / gnucalc / part47 < prev    next >
Encoding:
Text File  |  1991-11-01  |  55.5 KB  |  1,302 lines

  1. Newsgroups: comp.sources.misc
  2. From: daveg@synaptics.com (David Gillespie)
  3. Subject:  v24i095:  gnucalc - GNU Emacs Calculator, v2.00, Part47/56
  4. Message-ID: <1991Nov1.183859.21224@sparky.imd.sterling.com>
  5. X-Md4-Signature: e51a22d50957758770096c997cfde312
  6. Date: Fri, 1 Nov 1991 18:38:59 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: daveg@synaptics.com (David Gillespie)
  10. Posting-number: Volume 24, Issue 95
  11. Archive-name: gnucalc/part47
  12. Environment: Emacs
  13. Supersedes: gmcalc: Volume 13, Issue 27-45
  14.  
  15. ---- Cut Here and unpack ----
  16. #!/bin/sh
  17. # do not concatenate these parts, unpack them in order with /bin/sh
  18. # file calc.texinfo continued
  19. #
  20. if test ! -r _shar_seq_.tmp; then
  21.     echo 'Please unpack part 1 first!'
  22.     exit 1
  23. fi
  24. (read Scheck
  25.  if test "$Scheck" != 47; then
  26.     echo Please unpack part "$Scheck" next!
  27.     exit 1
  28.  else
  29.     exit 0
  30.  fi
  31. ) < _shar_seq_.tmp || exit 1
  32. if test ! -f _shar_wnt_.tmp; then
  33.     echo 'x - still skipping calc.texinfo'
  34. else
  35. echo 'x - continuing file calc.texinfo'
  36. sed 's/^X//' << 'SHAR_EOF' >> 'calc.texinfo' &&
  37. X
  38. @node Polynomial and Multilinear Fits, Error Estimates for Fits, Linear Fits, Curve Fitting
  39. @subsection Polynomial and Multilinear Fits
  40. X
  41. @noindent
  42. To fit the data to higher-order polynomials, just type one of the
  43. digits @kbd{2} through @kbd{9} when prompted for a model.  For example,
  44. we could fit the original data matrix from the previous section
  45. (with 13, not 14) to a parabola instead of a line by typing
  46. @kbd{a F 2 RET}.
  47. X
  48. @example
  49. 2.00000000001 x - 1.5e-12 x^2 + 2.99999999999
  50. @end example
  51. X
  52. Note that since the constant and linear terms are enough to fit the
  53. data exactly, it's no surprise that Calc chose a tiny contribution
  54. for @cite{x^2}.  (The fact that it's not exactly zero is due only
  55. to roundoff error.  Since our data are exact integers, we could get
  56. an exact answer by typing @kbd{m f} first to get fraction mode.
  57. Then the @cite{x^2} term would vanish altogether.  Usually, though,
  58. the data being fitted will be approximate floats so fraction mode
  59. won't help.)
  60. X
  61. Doing the @kbd{a F 2} fit on the data set with 14 instead of 13
  62. gives a much larger @cite{x^2} contribution, as Calc bends the
  63. line slightly to improve the fit.
  64. X
  65. @example
  66. 0.142857142855 x^2 + 1.34285714287 x + 3.59999999998
  67. @end example
  68. X
  69. An important result from the theory of polynomial fitting is that it
  70. is always possible to fit @i{N} data points exactly using a polynomial
  71. of degree @i{N-1}, sometimes called an @dfn{interpolating polynomial}.
  72. Using the modified (14) data matrix, a model number of 4 gives
  73. a polynomial that exactly matches all five data points:
  74. X
  75. @example
  76. 0.04167 x^4 - 0.4167 x^3 + 1.458 x^2 - 0.08333 x + 4.
  77. @end example
  78. X
  79. The actual coefficients we get with a precision of 12, like
  80. @cite{0.0416666663588}, clearly suffer from loss of precision.
  81. It is a good idea to increase the working precision to several
  82. digits beyond what you need when you do a fitting operation.
  83. Or, if your data are exact, use fraction mode to get exact
  84. results.
  85. X
  86. You can type @kbd{i} instead of a digit at the model prompt to fit
  87. the data exactly to a polynomial.  This just counts the number of
  88. columns of the data matrix to choose the degree of the polynomial
  89. automatically.
  90. X
  91. Fitting data ``exactly'' to high-degree polynomials is not always
  92. a good idea, though.  High-degree polynomials have a tendency to
  93. wiggle uncontrollably in between the fitting data points.  Also,
  94. if the exact-fit polynomial is going to be used to interpolate or
  95. extrapolate the data, it is numerically better to use the @kbd{a p}
  96. command described below.  @xref{Interpolation}.
  97. X
  98. @tex
  99. \bigskip
  100. @end tex
  101. X
  102. Another generalization of the linear model is to assume the
  103. @cite{y} values are a sum of linear contributions from several
  104. @cite{x} values.  This is a @dfn{multilinear} fit, and it is also
  105. selected by the @kbd{1} digit key.  (Calc decides whether the fit
  106. is linear or multilinear by counting the rows in the data matrix.)
  107. X
  108. Given the data matrix,
  109. X
  110. @group
  111. @example
  112. [ [  1,   2,   3,    4,   5  ]
  113. X  [  7,   2,   3,    5,   2  ]
  114. X  [ 14.5, 15, 18.5, 22.5, 24 ] ]
  115. @end example
  116. @end group
  117. X
  118. @noindent
  119. the command @kbd{a F 1 RET} will call the first row @cite{x} and the
  120. second row @cite{y}, and will fit the values in the third row to the
  121. model @cite{a + b x + c y}.
  122. X
  123. @example
  124. 8. + 3. x + 0.5 y
  125. @end example
  126. X
  127. Calc can do multilinear fits with any number of independent variables
  128. (i.e., with any number of data rows).
  129. X
  130. @tex
  131. \bigskip
  132. @end tex
  133. X
  134. Yet another variation is @dfn{homogeneous} linear models, in which
  135. the constant term is known to be zero.  In the linear case, this
  136. means the model formula is simply @cite{a x}; in the multilinear
  137. case, the model might be @kbd{a x + b y + c z}; and in the polynomial
  138. case, the model could be @kbd{a x + b x^2 + c x^3}.  You can get
  139. a homogeneous linear or multilinear model by pressing the letter
  140. @kbd{h} followed by a regular model key, like @kbd{1} or @kbd{2}.
  141. X
  142. It is certainly possible to have other constrained linear models,
  143. like @cite{2.3 + a x} or @kbd{a - 4 x}.  While there is no single
  144. key to select models like these, a later section shows how to enter
  145. any desired model by hand.  In the first case, for example, you
  146. would enter @kbd{a F ' 2.3 + a x}.
  147. X
  148. Another class of models that will work but must be entered by hand
  149. are multinomial fits, e.g., @cite{a + b x + c y + d x^2 + e y^2 + f x y}.
  150. X
  151. @node Error Estimates for Fits, Standard Nonlinear Models, Polynomial and Multilinear Fits, Curve Fitting
  152. @subsection Error Estimates for Fits
  153. X
  154. @noindent
  155. @kindex H a F
  156. @tindex efit
  157. With the Hyperbolic flag, @kbd{H a F} [@code{efit}] performs the same
  158. fitting operation as @kbd{a F}, but reports the coefficients as error
  159. forms instead of plain numbers.  Fitting our two data matrices (first
  160. with 13, then with 14) to a line with @kbd{H a F} gives the results,
  161. X
  162. @example
  163. 3. + 2. x
  164. 2.6 +/- 0.382970843103 + 2.2 +/- 0.115470053838 x
  165. @end example
  166. X
  167. In the first case the estimated errors are zero because the linear
  168. fit is perfect.  In the second case, the errors are nonzero but
  169. moderately small, because the data are still very close to linear.
  170. X
  171. It is also possible for the @emph{input} to a fitting operation to
  172. contain error forms.  The data values must either all include errors
  173. or all be plain numbers.  Error forms can go anywhere but generally
  174. go on the numbers in the last row of the data matrix.  If the last
  175. row contains error forms
  176. `@i{y_i} @t{+/-} @c{$\sigma_i$}
  177. @i{sigma_i}', then the @c{$\chi^2$}
  178. @cite{chi^2}
  179. statistic is now,
  180. X
  181. @ifinfo
  182. @example
  183. chi^2 = sum(((y_i - (a + b x_i)) / sigma_i)^2, i, 1, N)
  184. @end example
  185. @end ifinfo
  186. @tex
  187. \turnoffactive
  188. $$ \chi^2 = \sum_{i=1}^N \left(y_i - (a + b x_i) \over \sigma_i\right)^2 $$
  189. @end tex
  190. X
  191. @noindent
  192. so that data points with larger error estimates contribute less to
  193. the fitting operation.
  194. X
  195. If there are error forms on other rows of the data matrix, all the
  196. errors for a given data point are combined; the square root of the
  197. sum of the squares of the errors forms the @c{$\sigma_i$}
  198. @cite{sigma_i} used for
  199. the data point.
  200. X
  201. Both @kbd{a F} and @kbd{H a F} can accept error forms in the input
  202. matrix, although if you are concerned about error analysis you will
  203. probably use @kbd{H a F} so that the output also contains error
  204. estimates.
  205. X
  206. If the input contains error forms but all the @c{$\sigma_i$}
  207. @cite{sigma_i} values are
  208. the same, it is easy to see that the resulting fitted model will be
  209. the same as if the input did not have error forms at all (@c{$\chi^2$}
  210. @cite{chi^2}
  211. is simply scaled uniformly by @c{$1 / \sigma^2$}
  212. @cite{1 / sigma^2}, which doesn't affect
  213. where it has a minimum).  But there @emph{will} be a difference
  214. in the estimated errors of the coefficients reported by @kbd{H a F}.
  215. X
  216. Consult any text on statistical modelling of data for a discussion
  217. of where these error estimates come from and how they should be
  218. interpreted.
  219. X
  220. @tex
  221. \bigskip
  222. @end tex
  223. X
  224. @kindex I a F
  225. @tindex xfit
  226. With the Inverse flag, @kbd{I a F} [@code{xfit}] produces even more
  227. information.  The result is a vector of six items:
  228. X
  229. @enumerate
  230. @item
  231. The model formula with error forms for its coefficients or
  232. parameters.  This is the result that @kbd{H a F} would have
  233. produced.
  234. X
  235. @item
  236. A vector of ``raw'' parameter values for the model.  These are the
  237. polynomial coefficients or other parameters as plain numbers, in the
  238. same order as the parameters appeared in the final prompt of the
  239. @kbd{I a F} command.  For polynomials of degree @cite{d}, this vector
  240. will have length @cite{M = d+1} with the constant term first.
  241. X
  242. @item
  243. The covariance matrix @cite{C} computed from the fit.  This is
  244. an @i{M}x@i{M} symmetric matrix; the diagonal elements
  245. @c{$C_{jj}$}
  246. @cite{C_j_j} are the variances @c{$\sigma_j^2$}
  247. @cite{sigma_j^2} of the parameters.
  248. The other elements are covariances @c{$\sigma_{ij}^2$}
  249. @cite{sigma_i_j^2} that describe the
  250. correlation between pairs of parameters.  (A related set of
  251. numbers, the @dfn{linear correlation coefficients} @c{$r_{ij}$}
  252. @cite{r_i_j},
  253. are defined as @c{$\sigma_{ij}^2 / \sigma_i \, \sigma_j$}
  254. @cite{sigma_i_j^2 / sigma_i sigma_j}.)
  255. X
  256. @item
  257. A vector of @cite{M} ``parameter filter'' functions whose
  258. meanings are described below.  If no filters are necessary this
  259. will instead be an empty vector; this is always the case for the
  260. polynomial and multilinear fits described so far.
  261. X
  262. @item
  263. The value of @c{$\chi^2$}
  264. @cite{chi^2} for the fit, calculated by the formulas
  265. shown above.  This gives a measure of the quality of the fit;
  266. statisticians consider @c{$\chi^2 \approx N - M$}
  267. @cite{chi^2 = N - M} to indicate a moderately good fit
  268. (where again @cite{N} is the number of data points and @cite{M}
  269. is the number of parameters).
  270. X
  271. @item
  272. A measure of goodness of fit expressed as a probability @cite{Q}.
  273. This is computed from the @code{utpc} probability distribution
  274. function using @c{$\chi^2$}
  275. @cite{chi^2} with @cite{N - M} degrees of freedom.  A
  276. value of 0.5 implies a good fit; some texts recommend that often
  277. @cite{Q = 0.1} or even 0.001 can signify an acceptable fit.  In
  278. particular, @c{$\chi^2$}
  279. @cite{chi^2} statistics assume the errors in your inputs
  280. follow a normal (Gaussian) distribution; if they don't, you may
  281. have to accept smaller values of @cite{Q}.
  282. X
  283. The @cite{Q} value is computed only if the input included error
  284. estimates.  Otherwise, Calc will report the symbol @code{nan}
  285. for @cite{Q}.  The reason is that in this case the @c{$\chi^2$}
  286. @cite{chi^2}
  287. value has effectively been used to estimate the original errors
  288. in the input, and thus there is no redundant information left
  289. over to use for a confidence test.
  290. @end enumerate
  291. X
  292. @node Standard Nonlinear Models, Curve Fitting Details, Error Estimates for Fits, Curve Fitting
  293. @subsection Standard Nonlinear Models
  294. X
  295. @noindent
  296. The @kbd{a F} command also accepts other kinds of models besides
  297. lines and polynomials.  Some common models have quick single-key
  298. abbreviations; others must be entered by hand as algebraic formulas.
  299. X
  300. Here is a complete list of the standard models recognized by @kbd{a F}:
  301. X
  302. @table @kbd
  303. @item 1
  304. Linear or multilinear.  @i{a + b x + c y + d z}.
  305. @item 2-9
  306. Polynomials.  @i{a + b x + c x^2 + d x^3}.
  307. @item e
  308. Exponential.  @i{a} @t{exp}@i{(b x)} @t{exp}@i{(c y)}.
  309. @item E
  310. Base-10 exponential.  @i{a} @t{10^}@i{(b x)} @t{10^}@i{(c y)}.
  311. @item x
  312. Exponential (alternate notation).  @t{exp}@i{(a + b x + c y)}.
  313. @item X
  314. Base-10 exponential (alternate).  @t{10^}@i{(a + b x + c y)}.
  315. @item l
  316. Logarithmic.  @i{a + b} @t{ln}@i{(x) + c} @t{ln}@i{(y)}.
  317. @item L
  318. Base-10 logarithmic.  @i{a + b} @t{log10}@i{(x) + c} @t{log10}@i{(y)}.
  319. @item ^
  320. General exponential.  @i{a b^x c^y}.
  321. @item p
  322. Power law.  @i{a x^b y^c}.
  323. @item q
  324. Quadratic.  @i{a + b (x-c)^2 + d (x-e)^2}.
  325. @item g
  326. Gaussian.  @c{${a \over b \sqrt{2 \pi}} \exp\left( -{1 \over 2} \left( x - c \over b \right)^2 \right)$}
  327. @i{(a / b sqrt(2 pi)) exp(-0.5*((x-c)/b)^2)}.
  328. @end table
  329. X
  330. All of these models are used in the usual way; just press the appropriate
  331. letter at the model prompt, and choose variable names if you wish.  The
  332. result will be a formula as shown in the above table, with the best-fit
  333. values of the parameters substituted.  (You may find it easier to read
  334. the parameter values from the vector that is placed in the trail.)
  335. X
  336. All models except Gaussian can generalize as shown to any number of
  337. independent variables.  Also, all the built-in models have an additive
  338. or multiplicative parameter shown as @cite{a} in the above table
  339. which can be replaced by zero or one, as appropriate, by typing @kbd{h}
  340. before the model key.
  341. X
  342. Note that many of these models are essentially equivalent, but express
  343. the parameters slightly differently.  For example, @cite{a b^x} and
  344. the other two exponential models are all algebraic rearrangements of
  345. each other.  Also, the ``quadratic'' model is just a degree-2 polynomial
  346. with the parameters expressed differently.  Use whichever form best
  347. matches the problem.
  348. X
  349. The HP-28/48 calculators support four different models for curve
  350. fitting, called @code{LIN}, @code{LOG}, @code{EXP}, and @code{PWR}.
  351. These correspond to Calc models @samp{a + b x}, @samp{a + b ln(x)},
  352. @samp{a exp(b x)}, and @samp{a x^b}, respectively.  In each case,
  353. @cite{a} is what the HP-48 identifies as the ``intercept,'' and
  354. @cite{b} is what it calls the ``slope.''
  355. X
  356. @tex
  357. \bigskip
  358. @end tex
  359. X
  360. If the model you want doesn't appear on this list, press @kbd{'}
  361. (the apostrophe key) at the model prompt to enter any algebraic
  362. formula, such as @kbd{m x - b}, as the model.  (Not all models
  363. will work, though---see the next section for details.)
  364. X
  365. The model can also be an equation like @cite{y = m x + b}.
  366. In this case, Calc thinks of all the rows of the data matrix on
  367. equal terms; this model effectively has two parameters
  368. (@cite{m} and @cite{b}) and two independent variables (@cite{x}
  369. and @cite{y}), with no ``dependent'' variables.  Model equations
  370. do not need to take this @cite{y =} form.  For example, the
  371. implicit line equation @cite{a x + b y = 1} works fine as a
  372. model.
  373. X
  374. When you enter a model, Calc makes an alphabetical list of all
  375. the variables that appear in the model.  These are used for the
  376. default parameters, independent variables, and dependent variable
  377. (in that order).  If you enter a plain formula (not an equation),
  378. Calc assumes the dependent variable does not appear in the formula
  379. and thus does not need a name.
  380. X
  381. For example, if the model formula has the variables @cite{a,mu,sigma,t,x},
  382. and the data matrix has three rows (meaning two independent variables),
  383. Calc will use @cite{a,mu,sigma} as the default parameters, and the
  384. data rows will be named @cite{t} and @cite{x}, respectively.  If you
  385. enter an equation instead of a plain formula, Calc will use @cite{a,mu}
  386. as the parameters, @cite{sigma,t} as the independent variables, and
  387. @cite{x} as the dependent variable (so that @cite{sigma,t,x} stand for
  388. the three rows of the data matrix).
  389. X
  390. You can, of course, override these choices by entering something
  391. different at the prompt.  If you leave some variables out of the list,
  392. those variables must have stored values and those stored values will
  393. be used as constants in the model.  (Stored values for the parameters
  394. and independent variables are ignored by the @kbd{a F} command.)
  395. If you list only independent variables, all the remaining variables
  396. in the model formula will become parameters.
  397. X
  398. If there are @kbd{$} signs in the model you type, they will stand
  399. for parameters and all other variables (in alphabetical order)
  400. will be independent.  Use @kbd{$} for one parameter, @kbd{$$} for
  401. another, and so on.  Thus @kbd{$ x + $$} is another way to describe
  402. a linear model.
  403. X
  404. If you type a @kbd{$} instead of @kbd{'} at the model prompt itself,
  405. Calc will take the model formula from the stack.  (The data must then
  406. appear at the second stack level.)  The same conventions are used to
  407. choose which variables in the formula are independent by default and
  408. which are parameters.
  409. X
  410. Models taken from the stack can also be expressed as vectors of
  411. two or three elements, @samp{[@var{model}, @var{vars}]} or
  412. @cite{[@var{model}, @var{vars}, @var{params}]}.  Each of @var{vars}
  413. and @var{params} may be either variables or vectors of variables.
  414. (If @var{params} is omitted, all variables in @var{model} except
  415. those listed as @var{vars} are parameters.)@refill
  416. X
  417. When you enter a model manually with @kbd{'}, Calc puts a 3-vector
  418. describing the model in the trail so you can get it back if you wish.
  419. X
  420. @tex
  421. \bigskip
  422. @end tex
  423. X
  424. @vindex Model1
  425. @vindex Model2
  426. Finally, you can store a model in one of the Calc variables
  427. @code{Model1} or @code{Model2}, then use this model by typing
  428. @kbd{a F u} or @kbd{a F U} (respectively).  The value stored in
  429. the variable can be any of the formats that @kbd{a F $} would
  430. accept for a model on the stack.
  431. X
  432. @tex
  433. \bigskip
  434. @end tex
  435. X
  436. Calc uses the principal values of inverse functions like @code{ln}
  437. and @code{arcsin} when doing fits.  For example, when you enter
  438. the model @samp{y = sin(a t + b)} Calc actually uses the easier
  439. form @samp{arcsin(y) = a t + b}.  The @code{arcsin} function always
  440. returns results in the range from -90 to 90 degrees (or the
  441. equivalent range in radians).  Suppose you had data that you
  442. believed to represent roughly three oscillations of a sine wave,
  443. so that the argument of the sine might go from zero to 3*360 degrees.
  444. The above model would appear to be a good way to determine the
  445. true frequency and phase of the sine wave, but in practice it
  446. would fail utterly.  The righthand side of the actual model
  447. @samp{arcsin(y) = a t + b} will grow smoothly with @cite{t}, but
  448. the lefthand side will bounce back and forth between -90 and 90.
  449. No values of @cite{a} and @cite{b} can make the two sides match,
  450. even approximately.
  451. X
  452. There is no good solution to this problem at present.  You could
  453. restrict your data to small enough ranges so that the above problem
  454. doesn't occur (i.e., not straddling any peaks in the sine wave).
  455. Or, in this case, you could use a totally different method such as
  456. Fourier analysis, which is beyond the scope of the @kbd{a F} command.
  457. (Unfortunately, Calc does not currently have any facilities for
  458. taking Fourier and related transforms.)
  459. X
  460. @node Curve Fitting Details, Interpolation, Standard Nonlinear Models, Curve Fitting
  461. @subsection Curve Fitting Details
  462. X
  463. @noindent
  464. Calc's internal least-squares fitter can only handle multilinear
  465. models.  More precisely, it can handle any model of the form
  466. @cite{a f(x,y,z) + b g(x,y,z) + c h(x,y,z)}, where @cite{a,b,c}
  467. are the parameters and @cite{x,y,z} are the independent variables
  468. (of course there can be any number of each, not just three).
  469. X
  470. In a simple multilinear or polynomial fit, it is easy to see how
  471. to convert the model into this form.  For example, if the model
  472. is @cite{a + b x + c x^2}, then @cite{f(x) = 1}, @cite{g(x) = x},
  473. and @cite{h(x) = x^2} are suitable functions.
  474. X
  475. For other models, Calc uses a variety of algebraic manipulations
  476. to try to put the problem into the form
  477. X
  478. @smallexample
  479. Y(x,y,z) = A(a,b,c) F(x,y,z) + B(a,b,c) G(x,y,z) + C(a,b,c) H(x,y,z)
  480. @end smallexample
  481. X
  482. @noindent
  483. where @cite{Y,A,B,C,F,G,H} are arbitrary functions.  It computes
  484. @cite{Y}, @cite{F}, @cite{G}, and @cite{H} for all the data points,
  485. does a standard linear fit to find the values of @cite{A}, @cite{B},
  486. and @cite{C}, then uses the equation solver to solve for @cite{a,b,c}
  487. in terms of @cite{A,B,C}.
  488. X
  489. A remarkable number of models can be cast into this general form.
  490. We'll look at two examples here to see how it works.  The power-law
  491. model @cite{y = a x^b} with two independent variables and two parameters
  492. can be rewritten as follows:
  493. X
  494. @example
  495. y = a x^b
  496. y = a exp(b ln(x))
  497. y = exp(ln(a) + b ln(x))
  498. ln(y) = ln(a) + b ln(x)
  499. @end example
  500. X
  501. @noindent
  502. which matches the desired form with @cite{Y = ln(y)}, @cite{A = ln(a)},
  503. @cite{F = 1}, @cite{B = b}, and @cite{G = ln(x)}.  Calc thus computes
  504. the logarithms of your @cite{y} and @cite{x} values, does a linear fit
  505. for @cite{A} and @cite{B}, then solves to get @cite{a = exp(A)} and
  506. @cite{b = B}.
  507. X
  508. Another interesting example is the ``quadratic'' model, which can
  509. be handled by expanding according to the distributive law.
  510. X
  511. @example
  512. y = a + b*(x - c)^2
  513. y = a + b c^2 - 2 b c x + b x^2
  514. @end example
  515. X
  516. @noindent
  517. which matches with @cite{Y = y}, @cite{A = a + b c^2}, @cite{F = 1},
  518. @cite{B = -2 b c}, @cite{G = x} (the -2 factor could just as easily
  519. have been put into @cite{G} instead of @cite{B}), @cite{C = b}, and
  520. @cite{H = x^2}.
  521. X
  522. The Gaussian model looks quite complicated, but a closer examination
  523. shows that it's actually similar to the quadratic model but with an
  524. exponential that can be brought to the top and moved into @cite{Y}.
  525. X
  526. An example of a model that cannot be put into general linear
  527. form is a Gaussian with a constant background added on, i.e.,
  528. @cite{d} + the regular Gaussian formula.  If you have a model like
  529. this, your best bet is to replace enough of your parameters with
  530. constants to make the model linearizable, then adjust the constants
  531. manually by doing a series of fits.  You can compare the fits by
  532. graphing them, by examining the goodness-of-fit measures returned by
  533. @kbd{I a F}, or by some other method suitable to your application.
  534. Note that some models can be linearized in several ways.  The
  535. Gaussian-plus-@i{d} model can be linearized by setting @cite{d}
  536. (the background) to a constant, or by setting @cite{b} (the standard
  537. deviation) and @cite{c} (the mean) to constants.
  538. X
  539. To fit a model with constants substituted for some parameters, just
  540. store suitable values in those parameter variables, then omit them
  541. from the list of parameters when you answer the variables prompt.
  542. X
  543. @tex
  544. \bigskip
  545. @end tex
  546. X
  547. A last desperate step would be to use the general-purpose
  548. @code{minimize} function rather than @code{fit}.  After all, both
  549. functions solve the problem of minimizing an expression (the @c{$\chi^2$}
  550. @cite{chi^2}
  551. sum) by adjusting certain parameters in the expression.  The @kbd{a F}
  552. command is able to use a vastly more efficient algorithm due to its
  553. special knowledge about linear chi-square sums, but the @kbd{a N}
  554. command can do the same thing by brute force.
  555. X
  556. A compromise would be to pick out a few parameters without which the
  557. fit is linearizable, and use @code{minimize} on a call to @code{fit}
  558. which efficiently takes care of the rest of the parameters.  The thing
  559. to be minimized would be the value of @c{$\chi^2$}
  560. @cite{chi^2} returned as
  561. the fifth result of the @code{xfit} function:
  562. X
  563. @smallexample
  564. minimize(xfit(gaus(a,b,c,d,x), x, [a,b,c], data)_5, d, guess)
  565. @end smallexample
  566. X
  567. @noindent
  568. where @code{gaus} represents the Gaussian model with background,
  569. @code{data} represents the data matrix, and @code{guess} represents
  570. the initial guess for @cite{d} that @code{minimize} requires.
  571. This operation will only be, shall we say, extraordinarily slow
  572. rather than astronomically slow (as would be the case if @code{minimize}
  573. were used by itself to solve the problem).
  574. X
  575. @tex
  576. \bigskip
  577. @end tex
  578. X
  579. The @kbd{I a F} [@code{xfit}] command is somewhat trickier when
  580. nonlinear models are used.  The second item in the result is the
  581. vector of ``raw'' parameters @cite{A}, @cite{B}, @cite{C}.  The
  582. covariance matrix is written in terms of those raw parameters.
  583. The fifth item is a vector of @dfn{filter} expressions.  This
  584. is the empty vector @samp{[]} if the raw parameters were the same
  585. as the requested parameters, i.e., if @cite{A = a}, @cite{B = b},
  586. and so on (which is always possible if the model is already linear
  587. in the parameters as written, e.g., for polynomial fits).  If the
  588. parameters had to be rearranged, the fifth item is instead a vector
  589. of one formula per parameter in the original model.  The raw
  590. parameters are expressed in these ``filter'' formulas as
  591. @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)} for @cite{B},
  592. and so on.
  593. X
  594. When Calc needs to modify the model to return the result, it replaces
  595. @samp{fitdummy(1)} in all the filters with the first item in the raw
  596. parameters list, and so on for the other raw parameters, then
  597. evaluates the resulting filter formulas to get the actual parameter
  598. values to be substituted into the original model.  In the case of
  599. @kbd{H a F} and @kbd{I a F} where the parameters must be error forms,
  600. Calc uses the square roots of the diagonal entries of the covariance
  601. matrix as error values for the raw parameters, then lets Calc's
  602. standard error-form arithmetic take it from there.
  603. X
  604. If you use @kbd{I a F} with a nonlinear model, be sure to remember
  605. that the covariance matrix is in terms of the raw parameters,
  606. @emph{not} the actual requested parameters.  It's up to you to
  607. figure out how to interpret the covariances in the presence of
  608. nontrivial filter functions.
  609. X
  610. Things are also complicated when the input contains error forms.
  611. Suppose there are three independent and dependent variables, @cite{x},
  612. @cite{y}, and @cite{z}, one or more of which are error forms in the
  613. data.  Calc combines all the error values by taking the square root
  614. of the sum of the squares of the errors.  It then changes @cite{x}
  615. and @cite{y} to be plain numbers, and makes @cite{z} into an error
  616. form with this combined error.  The @cite{Y(x,y,z)} part of the
  617. linearized model is evaluated, and the result should be an error
  618. form.  The error part of that result is used for @c{$\sigma_i$}
  619. @cite{sigma_i} for
  620. the data point.  If for some reason @cite{Y(x,y,z)} does not return
  621. an error form, the combined error from @cite{z} is used directly
  622. for @c{$\sigma_i$}
  623. @cite{sigma_i}.  Finally, @cite{z} is also stripped of its error
  624. for use in computing @cite{F(x,y,z)}, @cite{G(x,y,z)} and so on;
  625. the righthand side of the linearized model is computed in regular
  626. arithmetic with no error forms.
  627. X
  628. (While these rules may seem complicated, they are designed to do
  629. the most reasonable thing in the typical case that @cite{Y(x,y,z)}
  630. depends only on the dependent variable @cite{z}, and in fact is
  631. often simply equal to @cite{z}.  For common cases like polynomials
  632. and multilinear models, the combined error is simply used as the
  633. @c{$\sigma$}
  634. @cite{sigma} for the data point with no further ado.)
  635. X
  636. @tex
  637. \bigskip
  638. @end tex
  639. X
  640. @vindex FitRules
  641. It may be the case that the model you wish to use is linearizable,
  642. but Calc's built-in rules are unable to figure it out.  Calc uses
  643. its algebraic rewrite mechanism to linearize a model.  The rewrite
  644. rules are kept in the variable @code{FitRules}.  You can edit this
  645. variable using the @kbd{s e FitRules} command; in fact, there is
  646. a special @kbd{s F} command just for editing @code{FitRules}.
  647. @xref{Operations on Variables}.
  648. X
  649. @xref{Rewrite Rules}, for a discussion of rewrite rules.
  650. X
  651. @tindex fitvar
  652. @tindex fitparam
  653. @tindex fitmodel
  654. @tindex fitsystem
  655. @tindex fitdummy
  656. Calc uses @code{FitRules} as follows.  First, it converts the model
  657. to an equation if necessary and encloses the model equation in a
  658. call to the function @code{fitmodel} (which is not actually defined
  659. by Calc; it is only used as a placeholder by the rewrite rules).
  660. Parameter variables are renamed to function calls @samp{fitparam(1)},
  661. @samp{fitparam(2)}, and so on, and independent variables are renamed
  662. to @samp{fitvar(1)}, @samp{fitvar(2)}, etc.  The dependent variable
  663. is the highest-numbered @code{fitvar}.  For example, the power law
  664. model @cite{a x^b} is converted to @cite{y = a x^b}, then to
  665. X
  666. @group
  667. @smallexample
  668. fitmodel(fitvar(2) = fitparam(1) fitvar(1)^fitparam(2))
  669. @end smallexample
  670. @end group
  671. X
  672. Calc then applies the rewrites as if by @samp{C-u 0 a r FitRules}.
  673. (The zero prefix means that rewriting should continue until no further
  674. changes are possible.)
  675. X
  676. When rewriting is complete, the @code{fitmodel} call should have
  677. been replaced by a @code{fitsystem} call that looks like this:
  678. X
  679. @example
  680. fitsystem(@var{Y}, @var{FGH}, @var{abc})
  681. @end example
  682. X
  683. @noindent
  684. where @var{Y} is a formula that describes the function @cite{Y(x,y,z)},
  685. @var{FGH} is the vector of formulas @cite{[F(x,y,z), G(x,y,z), H(x,y,z)]},
  686. and @var{abc} is the vector of parameter filters which refer to the
  687. raw parameters as @samp{fitdummy(1)} for @cite{A}, @samp{fitdummy(2)}
  688. for @cite{B}, etc.  While the number of raw parameters (the length of
  689. the @var{FGH} vector) is usually the same as the number of original
  690. parameters (the length of the @var{abc} vector), this is not required.
  691. X
  692. The power law model eventually boils down to
  693. X
  694. @group
  695. @smallexample
  696. fitsystem(ln(fitvar(2)),
  697. X          [1, ln(fitvar(1))],
  698. X          [exp(fitdummy(1)), fitdummy(2)])
  699. @end smallexample
  700. @end group
  701. X
  702. The actual implementation of @code{FitRules} is complicated; it
  703. proceeds in four phases.  First, common rearrangements are done
  704. to try to bring linear terms together and isolate functions like
  705. @code{exp} and @code{ln} either all the way ``out'' (so that they
  706. can be put into @var{Y}) or all the way ``in'' (so that they can
  707. be put into @var{abc} or @var{FGH}).  In particular, all
  708. non-constant powers are converted to logs-and-exponentials form,
  709. and the distributive law is used to expand products of sums.
  710. Quotients are rewritten to use the @samp{fitinv} function, where
  711. @samp{fitinv(x)} represents @cite{1/x} while the @code{FitRules}
  712. are operating.  (The use of @code{fitinv} makes recognition of
  713. linear-looking forms easier.)  If you modify @code{FitRules}, you
  714. will probably only need to modify the rules for this phase.
  715. X
  716. Phase two, whose rules can actually also apply during phases one
  717. and three, first rewrites @code{fitmodel} to a two-argument
  718. form @samp{fitmodel(@var{Y}, @var{model})}, where @var{Y} is
  719. initially zero and @var{model} has been changed from @cite{a=b}
  720. to @cite{a-b} form.  It then tries to peel off invertible functions
  721. from the outside of @var{model} and put them into @var{Y} instead,
  722. calling the equation solver to invert the functions.  Finally, when
  723. this is no longer possible, the @code{fitmodel} is changed to a
  724. four-argument @code{fitsystem}, where the fourth argument is
  725. @var{model} and the @var{FGH} and @var{abc} vectors are initially
  726. empty.  (The last vector is really @var{ABC}, corresponding to
  727. raw parameters, for now.)
  728. X
  729. Phase three converts a sum of items in the @var{model} to a sum
  730. of @samp{fitpart(@var{a}, @var{b}, @var{c})} terms which represent
  731. terms @samp{@var{a}*@var{b}*@var{c}} of the sum, where @var{a}
  732. is all factors that do not involve any variables, @var{b} is all
  733. factors that involve only parameters, and @var{c} is the factors
  734. that involve only independent variables.  (If this decomposition
  735. is not possible, the rule set will not complete and Calc will
  736. complain that the model is too complex.)  Then @code{fitpart}s
  737. with equal @var{b} or @var{c} components are merged back together
  738. using the distributive law in order to minimize the number of
  739. raw parameters needed.
  740. X
  741. Phase four moves the @code{fitpart} terms into the @var{FGH} and
  742. @var{ABC} vectors.  Also, some of the algebraic expansions that
  743. were done in phase 1 are undone now to make the formulas more
  744. computationally efficient.  Finally, it calls the solver one more
  745. time to convert the @var{ABC} vector to an @var{abc} vector, and
  746. removes the fourth @var{model} argument (which by now will be zero)
  747. to obtain the three-argument @code{fitsystem} that the linear
  748. least-squares solver wants to see.
  749. X
  750. @tindex hasfitparams
  751. @tindex hasfitvars
  752. Two functions which are useful in connection with @code{FitRules}
  753. are @samp{hasfitparams(x)} and @samp{hasfitvars(x)}, which check
  754. whether @cite{x} refers to any parameters or independent variables,
  755. respectively.  Specifically, these functions return ``true'' if the
  756. argument contains any @code{fitparam} (or @code{fitvar}) function
  757. calls, and ``false'' otherwise.  (Recall that ``true'' means a
  758. nonzero number, and ``false'' means zero.  The actual nonzero number
  759. returned is the largest @var{n} from all the @samp{fitparam(@var{n})}s
  760. or @samp{fitvar(@var{n})}s, respectively, that appear in the formula.)
  761. X
  762. @tex
  763. \bigskip
  764. @end tex
  765. X
  766. The @code{fit} function in algebraic notation normally takes four
  767. arguments, @samp{fit(@var{model}, @var{vars}, @var{params}, @var{data})},
  768. where @var{model} is the model formula as it would be typed after
  769. @kbd{a F '}, @var{vars} is the independent variable or a vector of
  770. independent variables, @var{params} likewise gives the parameter(s),
  771. and @var{data} is the data matrix.  Note that the length of @var{vars}
  772. must be equal to the number of rows in @var{data} if @var{model} is
  773. an equation, or one less than the number of rows if @var{model} is
  774. a plain formula.  (Actually, a name for the dependent variable is
  775. allowed but will be ignored in the plain-formula case.)
  776. X
  777. If @var{params} is omitted, the parameters are all variables in
  778. @var{model} except those that appear in @var{vars}.  If @var{vars}
  779. is also omitted, Calc sorts all the variables that appear in
  780. @var{model} alphabetically and uses the higher ones for @var{vars}
  781. and the lower ones for @var{params}.
  782. X
  783. Alternatively, @samp{fit(@var{modelvec}, @var{data})} is allowed
  784. where @var{modelvec} is a 2- or 3-vector describing the model
  785. and variables, as discussed previously.
  786. X
  787. If Calc is unable to do the fit, the @code{fit} function is left
  788. in symbolic form, ordinarily with an explanatory message.  The
  789. message will be ``Model expression is too complex'' if the
  790. linearizer was unable to put the model into the required form.
  791. X
  792. The @code{efit} (corresponding to @kbd{H a F}) and @code{xfit}
  793. (for @kbd{I a F}) functions are completely analogous.
  794. X
  795. @node Interpolation, ,  Curve Fitting Details, Curve Fitting
  796. @subsection Polynomial Interpolation
  797. X
  798. @kindex a p
  799. @pindex calc-poly-interp
  800. @tindex polint
  801. The @kbd{a p} (@code{calc-poly-interp}) [@code{polint}] command does
  802. a polynomial interpolation at a particular @cite{x} value.  It takes
  803. two arguments from the stack:  A data matrix of the sort used by
  804. @kbd{a F}, and a single number which represents the desired @cite{x}
  805. value.  Calc effectively does an exact polynomial fit as if by @kbd{a F i},
  806. then substitutes the @cite{x} value into the result in order to get an
  807. approximate @cite{y} value based on the fit.  (Calc does not actually
  808. use @kbd{a F i}, however; it uses a direct method which is both more
  809. efficient and more numerically stable.)
  810. X
  811. The result of @kbd{a p} is actually a vector of two values:  The @cite{y}
  812. value approximation, and an error measure @cite{dy} that reflects Calc's
  813. estimation of the probable error of the approximation at that value of
  814. @cite{x}.  If the input @cite{x} is equal to any of the @cite{x} values
  815. in the data matrix, the output @cite{y} will be the corresponding @cite{y}
  816. value from the matrix, and the output @cite{dy} will be exactly zero.
  817. X
  818. A prefix argument of 2 causes @kbd{a p} to take two vectors (@cite{x}
  819. and @cite{y}) from the stack instead of one data matrix.
  820. X
  821. If @cite{x} is a vector of numbers, @kbd{a p} will return a matrix of
  822. interpolated results for each of those @cite{x} values.  (The matrix will
  823. have two columns, the @cite{y} values and the @cite{dy} values.)
  824. If @cite{x} is a formula instead of a number, the @code{polint} function
  825. remains in symbolic form; use the @kbd{a "} command to expand it out to
  826. a formula that describes the fit in symbolic terms.
  827. X
  828. In all cases, the @kbd{a p} command leaves the data vectors or matrix
  829. on the stack.  Only the @cite{x} value is replaced by the result.
  830. X
  831. @kindex H a p
  832. @tindex ratint
  833. The @kbd{H a p} [@code{ratint}] command does a rational function
  834. interpolation.  It is used exactly like @kbd{a p}, except that it
  835. uses as its model the quotient of two polynomials.  If there are
  836. @cite{N} data points, the numerator and denominator polynomials will
  837. each have degree @cite{N/2} (if @cite{N} is odd, the denominator will
  838. have degree one higher than the numerator).
  839. X
  840. Rational approximations have the advantage that they can accurately
  841. describe functions that have poles (points at which the function's value
  842. goes to infinity, so that the denominator polynomial of the approximation
  843. goes to zero).  If @cite{x} corresponds to a pole of the fitted rational
  844. function, then the result will be a division by zero.  If Infinite mode
  845. is enabled, the result will be @samp{[uinf, uinf]}.
  846. X
  847. There is no way to get the actual coefficients of the rational function
  848. used by @kbd{H a p}.  (The algorithm never generates these coefficients
  849. explicitly, and quotients of polynomials are beyond @kbd{a F}'s
  850. capabilities to fit.)
  851. X
  852. @node Summations, Logical Operations, Curve Fitting, Algebra
  853. @section Summations
  854. X
  855. @noindent
  856. @cindex Summation of a series
  857. @kindex a +
  858. @pindex calc-summation
  859. @tindex sum
  860. The @kbd{a +} (@code{calc-summation}) [@code{sum}] command computes
  861. the sum of a formula over a certain range of indices.  The formula
  862. is taken from the top of the stack; the command prompts for the
  863. name of the summation index variable, the lower limit of the
  864. sum (any formula), and the upper limit of the sum.  If you
  865. enter a blank line at any of these prompts, that prompt and
  866. any later ones are answered by reading additional elements from
  867. the stack.  Thus, @kbd{' k^2 RET ' k RET 1 RET 5 RET a + RET}
  868. produces the result 55.
  869. @tex
  870. \turnoffactive
  871. $$ \sum_{k=1}^5 k^2 = 55 $$
  872. @end tex
  873. X
  874. The choice of index variable is arbitrary, but it's best not to
  875. use a variable with a stored value.  In particular, while
  876. @code{i} is often a favorite index variable, it should be avoided
  877. in Calc because @code{i} has the imaginary constant @cite{(0, 1)}
  878. as a value.  If you pressed @kbd{=} on a sum over @code{i}, it would
  879. be changed to a nonsensical sum over the ``variable'' @cite{(0, 1)}!
  880. If you really want to use @code{i} as an index variable, use
  881. @kbd{s u i RET} first to ``unstore'' this variable.
  882. (@xref{Storing Variables}.)
  883. X
  884. A numeric prefix argument steps the index by that amount rather
  885. than by one.  Thus @kbd{' a_k RET C-u -2 a + k RET 10 RET 0 RET}
  886. yields @samp{a_10 + a_8 + a_6 + a_4 + a_2 + a_0}.  A prefix
  887. argument of plain @kbd{C-u} causes @kbd{a +} to prompt for the
  888. step value, in which case you can enter any formula or enter
  889. a blank line to take the step value from the stack.  With the
  890. @kbd{C-u} prefix, @kbd{a +} can take up to five arguments from
  891. the stack:  The formula, the variable, the lower limit, the
  892. upper limit, and (at the top of the stack), the step value.
  893. X
  894. Calc knows how to do certain sums in closed form.  For example,
  895. @samp{sum(6 k^2, k, 1, n) = 2 n^3 + 3 n^2 + n}.  In particular,
  896. this is possible if the formula being summed is polynomial or
  897. exponential in the index variable.  Sums of logarithms are
  898. transformed into logarithms of products.  Sums of trigonometric
  899. and hyperbolic functions are transformed to sums of exponentials
  900. and then done in closed form.  Also, of course, sums in which the
  901. lower and upper limits are both numbers can always be evaluated
  902. just by grinding them out, although Calc will use closed forms
  903. whenever it can for the sake of efficiency.
  904. X
  905. The notation for sums in algebraic formulas is
  906. @samp{sum(@var{expr}, @var{var}, @var{low}, @var{high}, @var{step})}.
  907. If @var{step} is omitted, it defaults to one.  If @var{high} is
  908. omitted, @var{low} is actually the upper limit and the lower limit
  909. is one.  If @var{low} is also omitted, the limits are @samp{-inf}
  910. and @samp{inf}, respectively.
  911. X
  912. Infinite sums can sometimes be evaluated:  @samp{sum(.5^k, k, 1, inf)}
  913. returns @cite{1}.  This is done by evaluating the sum in closed
  914. form (to @samp{1. - 0.5^n} in this case), then evaluating this
  915. formula with @code{n} set to @code{inf}.  Calc's usual rules
  916. for ``infinite'' arithmetic can find the answer from here.  If
  917. infinite arithmetic yields a @samp{nan}, or if the sum cannot be
  918. solved in closed form, Calc leaves the @code{sum} function in
  919. symbolic form.  @xref{Infinities}.
  920. X
  921. As a special feature, if the limits are infinite (or omitted, as
  922. described above) but the formula includes vectors subscripted by
  923. expressions that include the iteration variable, Calc narrows
  924. the limits to include only the range of integers which result in
  925. legal subscripts for the vector.  For example, the sum
  926. @samp{sum(k [a,b,c,d,e,f,g]_(2k),k)} evaluates to @samp{b + 2 d + 3 f}.
  927. X
  928. The limits of a sum do not need to be integers.  For example,
  929. @samp{sum(a_k, k, 0, 2 n, n)} produces @samp{a_0 + a_n + a_(2 n)}.
  930. Calc computes the number of iterations using the formula
  931. @samp{1 + (@var{high} - @var{low}) / @var{step}}, which must,
  932. after simplification as if by @kbd{a s}, evaluate to an integer.
  933. X
  934. If the number of iterations according to the above formula does
  935. not come out to an integer, the sum is illegal and will be left
  936. in symbolic form.  However, closed forms are still supplied, and
  937. you are on your honor not to misuse the resulting formulas by
  938. substituting mismatched bounds into them.  For example,
  939. @samp{sum(k, k, 1, 10, 2)} is invalid, but Calc will go ahead and
  940. evaluate the closed form solution for the limits 1 and 10 to get
  941. the rather dubious answer, 29.25.
  942. X
  943. If the lower limit is greater than the upper limit (assuming a
  944. positive step size), the result is generally zero.  However,
  945. Calc only guarantees a zero result when the upper limit is
  946. exactly one step less than the lower limit, i.e., if the number
  947. of iterations is @i{-1}.  Thus @samp{sum(f(k), k, n, n-1)} is zero
  948. but the sum from @samp{n} to @samp{n-2} may report a nonzero value
  949. if closed form solutions were used.
  950. X
  951. Calc's logical predicates like @cite{a < b} return 1 for ``true''
  952. and 0 for ``false.''  @xref{Logical Operations}.  This can be
  953. used to advantage for building conditional sums.  For example,
  954. @samp{sum(prime(k)*k^2, k, 1, 20)} is the sum of the squares of all
  955. prime numbers from 1 to 20; the @code{prime} predicate returns 1 if
  956. its argument is prime and 0 otherwise.  You can read this expression
  957. as ``the sum of @cite{k^2}, where @cite{k} is prime.''  Indeed,
  958. @samp{sum(prime(k)*k^2, k)} would represent the sum of @emph{all} primes
  959. squared, since the limits default to plus and minus infinity, but
  960. there are no such sums that Calc's built-in rules can write in
  961. closed form.
  962. X
  963. As another example, @samp{sum((k != k_0) * f(k), k, 1, n)} is the
  964. sum of @cite{f(k)} for all @cite{k} from 1 to @cite{n}, excluding
  965. one value @cite{k_0}.  Slightly more tricky is the summand
  966. @samp{(k != k_0) / (k - k_0)}, which is an attempt to describe
  967. the sum of all @cite{1/(k-k_0)} except at @cite{k = k_0}, where
  968. this would be a division by zero.  But at @cite{k = k_0}, this
  969. formula works out to the indeterminate form @cite{0 / 0}, which
  970. Calc will not assume is zero.  Better would be to use
  971. @samp{(k != k_0) ? 1/(k-k_0) : 0}; the @samp{? :} operator does
  972. an ``if-then-else'' test:  This expression says, ``if @c{$k \ne k_0$}
  973. @cite{k != k_0},
  974. then @cite{1/(k-k_0)}, else zero.''  Now the formula @cite{1/(k-k_0)}
  975. will not even be evaluated by Calc when @cite{k = k_0}.
  976. X
  977. @cindex Alternating sums
  978. @kindex a -
  979. @pindex calc-alt-summation
  980. @tindex asum
  981. The @kbd{a -} (@code{calc-alt-summation}) [@code{asum}] command
  982. computes an alternating sum.  Successive terms of the sequence
  983. are given alternating signs, with the first term (corresponding
  984. to the lower index value) being positive.  Alternating sums
  985. are converted to normal sums with an extra term of the form
  986. @samp{(-1)^(k-@var{low})}.  This formula is adjusted appropriately
  987. if the step value is other than one.  For example, the Taylor
  988. series for the sine function is @samp{asum(x^k / k!, k, 1, inf, 2)}.
  989. (Calc cannot evaluate this infinite series, but it can approximate
  990. it if you replace @code{inf} with any particular odd number.)
  991. Calc converts this series to a regular sum with a step of one,
  992. namely @samp{sum((-1)^k x^(2k+1) / (2k+1)!, k, 0, inf)}.
  993. X
  994. @cindex Product of a sequence
  995. @kindex a *
  996. @pindex calc-product
  997. @tindex prod
  998. The @kbd{a *} (@code{calc-product}) [@code{prod}] command is
  999. the analogous way to take a product of many terms.  Calc also knows
  1000. some closed forms for products, such as @samp{prod(k, k, 1, n) = n!}.
  1001. Conditional products can be written, e.g., @samp{prod(k^prime(k), k, 1, n)}
  1002. or @samp{prod(prime(k) ? k : 1, k, 1, n)}.
  1003. X
  1004. @kindex a T
  1005. @pindex calc-tabulate
  1006. @tindex table
  1007. The @kbd{a T} (@code{calc-tabulate}) [@code{table}] command
  1008. evaluates a formula at a series of iterated index values, just
  1009. like @code{sum} and @code{prod}, but its result is simply a
  1010. vector of the results.  For example, @samp{table(a_i, i, 1, 7, 2)}
  1011. produces @samp{[a_1, a_3, a_5, a_7]}.
  1012. X
  1013. @node Logical Operations, Rewrite Rules, Summations, Algebra
  1014. @section Logical Operations
  1015. X
  1016. @noindent
  1017. The following commands and algebraic functions return true/false values,
  1018. where 1 represents ``true'' and 0 represents ``false.''  In cases where
  1019. a truth value is required (such as for the condition part of a rewrite
  1020. rule, or as the condition for a @kbd{Z [  Z ]} control structure), any
  1021. nonzero value is accepted to mean ``true.''  (Specifically, anything
  1022. for which @code{dnonzero} returns 1 is ``true,'' and anything for
  1023. which @code{dnonzero} returns 0 or cannot decide is assumed ``false.''
  1024. Note that this means that @kbd{Z [  Z ]} will execute the ``then''
  1025. portion if its condition is provably true, but it will execute the
  1026. ``else'' portion if for any condition like @cite{a = b} that is not
  1027. provably true, even if it might be true.  Algebraic functions that
  1028. have conditions as arguments, like @code{if} and @code{land}, remain
  1029. unevaluated if the condition is neither provably true nor provable
  1030. false.  @xref{Declarations}.)
  1031. X
  1032. @kindex a =
  1033. @pindex calc-equal-to
  1034. @tindex eq
  1035. @tindex =
  1036. @tindex ==
  1037. The @kbd{a =} (@code{calc-equal-to}) command, or @samp{eq(a,b)} function
  1038. (which can also be written @samp{a = b} or @samp{a == b} in an algebraic
  1039. formula) is true if @cite{a} and @cite{b} are equal, either because they
  1040. are identical expressions, or because they are numbers which are
  1041. numerically equal.  (Thus the integer 1 is considered equal to the float
  1042. 1.0.)  If the equality of @cite{a} and @cite{b} cannot be determined,
  1043. the comparison is left in symbolic form.  Note that as a command, this
  1044. operation pops two values from the stack and pushes back either a 1 or
  1045. a 0, or a formula @samp{a = b} if the values' equality cannot be determined.
  1046. X
  1047. Many Calc commands use @samp{=} formulas to represent @dfn{equations}.
  1048. For example, the @kbd{a S} (@code{calc-solve-for}) command rearranges
  1049. an equation to solve for a given variable.  The @kbd{a M}
  1050. (@code{calc-map-equation}) command can be used to apply any
  1051. function to both sides of an equation; for example, @kbd{2 a M *}
  1052. multiplies both sides of the equation by two.  Note that just
  1053. @kbd{2 *} would not do the same thing; it would produce the formula
  1054. @samp{2 (a = b)} which represents 2 if the equality is true or
  1055. zero if not.
  1056. X
  1057. The @code{eq} function with more than two arguments (e.g., @kbd{C-u 3 a =}
  1058. or @samp{a = b = c}) tests if all of its arguments are equal.  In
  1059. algebraic notation, the @samp{=} operator is unusual in that it is
  1060. neither left- nor right-associative:  @samp{a = b = c} is not the
  1061. same as @samp{(a = b) = c} or @samp{a = (b = c)} (which each compare
  1062. one variable with the 1 or 0 that results from comparing two other
  1063. variables).
  1064. X
  1065. @kindex a #
  1066. @pindex calc-not-equal-to
  1067. @tindex neq
  1068. @tindex !=
  1069. The @kbd{a #} (@code{calc-not-equal-to}) command, or @samp{neq(a,b)} or
  1070. @samp{a != b} function, is true if @cite{a} and @cite{b} are not equal.
  1071. This also works with more than two arguments; @samp{a != b != c != d}
  1072. tests that all four of @cite{a}, @cite{b}, @cite{c}, and @cite{d} are
  1073. distinct numbers.
  1074. X
  1075. @kindex a <
  1076. @kindex a >
  1077. @kindex a [
  1078. @kindex a ]
  1079. @pindex calc-less-than
  1080. @pindex calc-greater-than
  1081. @pindex calc-less-equal
  1082. @pindex calc-greater-equal
  1083. @tindex lt
  1084. @tindex gt
  1085. @tindex leq
  1086. @tindex geq
  1087. @tindex <
  1088. @tindex >
  1089. @tindex <=
  1090. @tindex >=
  1091. The @kbd{a <} (@code{calc-less-than}) [@samp{lt(a,b)} or @samp{a < b}]
  1092. operation is true if @cite{a} is less than @cite{b}.  Similar functions
  1093. are @kbd{a >} (@code{calc-greater-than}) [@samp{gt(a,b)} or @samp{a > b}],
  1094. @kbd{a [} (@code{calc-less-equal}) [@samp{leq(a,b)} or @samp{a <= b}], and
  1095. @kbd{a ]} (@code{calc-greater-equal}) [@samp{geq(a,b)} or @samp{a >= b}].
  1096. X
  1097. While the inequality functions like @code{lt} do not accept more
  1098. than two arguments, the syntax @samp{a <= b < c} is translated to an
  1099. equivalent expression involving intervals: @samp{b in [a .. c)}.
  1100. (See the description of @code{in} below.)  All four combinations
  1101. of @samp{<} and @samp{<=} are allowed, or any of the four combinations
  1102. of @samp{>} and @samp{>=}.  Four-argument constructions like
  1103. @samp{a < b < c < d}, and mixtures like @samp{a < b = c} that
  1104. involve both equalities and inequalities, are not allowed.
  1105. X
  1106. @kindex a .
  1107. @pindex calc-remove-equal
  1108. @tindex rmeq
  1109. The @kbd{a .} (@code{calc-remove-equal}) [@code{rmeq}] command extracts
  1110. the righthand side of the equation or inequality on the top of the
  1111. stack.  It also works elementwise on vectors.  For example, if
  1112. @samp{[x = 2.34, y = z / 2]} is on the stack, then @kbd{a .} produces
  1113. @samp{[2.34, z / 2]}.  As a special case, if the righthand side is a
  1114. variable and the lefthand side is a number (as in @samp{2.34 = x}), then
  1115. Calc keeps the lefthand side instead.  Finally, this command works with
  1116. assignments @samp{x := 2.34} as well as equations, always taking the
  1117. the righthand side, and for @samp{=>} (evaluates-to) operators, always
  1118. taking the lefthand side.
  1119. X
  1120. @kindex a &
  1121. @pindex calc-logical-and
  1122. @tindex land
  1123. @tindex &&
  1124. The @kbd{a &} (@code{calc-logical-and}) [@samp{land(a,b)} or @samp{a && b}]
  1125. function is true if both of its arguments are true, i.e., are
  1126. non-zero numbers.  In this case, the result will be either @cite{a} or
  1127. @cite{b}, chosen arbitrarily.  If either argument is zero, the result is
  1128. zero.  Otherwise, the formula is left in symbolic form.
  1129. X
  1130. @kindex a |
  1131. @pindex calc-logical-or
  1132. @tindex lor
  1133. @tindex ||
  1134. The @kbd{a |} (@code{calc-logical-or}) [@samp{lor(a,b)} or @samp{a || b}]
  1135. function is true if either or both of its arguments are true (nonzero).
  1136. The result is whichever argument was nonzero, choosing arbitrarily if both
  1137. are nonzero.  If both @cite{a} and @cite{b} are zero, the result is
  1138. zero.
  1139. X
  1140. @kindex a !
  1141. @pindex calc-logical-not
  1142. @tindex lnot
  1143. @tindex !
  1144. The @kbd{a !} (@code{calc-logical-not}) [@samp{lnot(a)} or @samp{!@: a}]
  1145. function is true if @cite{a} is false (zero), or false if @cite{a} is
  1146. true (nonzero).  It is left in symbolic form if @cite{a} is not a
  1147. number.
  1148. X
  1149. @kindex a :
  1150. @pindex calc-logical-if
  1151. @tindex if
  1152. @tindex ?
  1153. @tindex :
  1154. @cindex Arguments, not evaluated
  1155. The @kbd{a :} (@code{calc-logical-if}) [@samp{if(a,b,c)} or @samp{a ? b :@: c}]
  1156. function is equal to either @cite{b} or @cite{c} if @cite{a} is a nonzero
  1157. number or zero, respectively.  If @cite{a} is not a number, the test is
  1158. left in symbolic form and neither @cite{b} nor @cite{c} is evaluated in
  1159. any way.  In algebraic formulas, this is one of the few Calc functions
  1160. whose arguments are not automatically evaluated when the function itself
  1161. is evaluated.  The others are @code{lambda}, @code{quote}, and
  1162. @code{condition}.
  1163. X
  1164. One minor surprise to watch out for is that the formula @samp{a?3:4}
  1165. will not work because the @samp{3:4} is parsed as a fraction instead of
  1166. as three separate symbols.  Type something like @samp{a ? 3 : 4} or
  1167. @samp{a?(3):4} instead.
  1168. X
  1169. As a special case, if @cite{a} evaluates to a vector, then both @cite{b}
  1170. and @cite{c} are evaluated; the result is a vector of the same length
  1171. as @cite{a} whose elements are chosen from corresponding elements of
  1172. @cite{b} and @cite{c} according to whether each element of @cite{a}
  1173. is zero or nonzero.  Each of @cite{b} and @cite{c} must be either a
  1174. vector of the same length as @cite{a}, or a non-vector which is matched
  1175. with all elements of @cite{a}.
  1176. X
  1177. @kindex a @{
  1178. @pindex calc-in-set
  1179. @tindex in
  1180. The @kbd{a @{} (@code{calc-in-set}) [@samp{in(a,b)}] function is true if
  1181. the number @cite{a} is in the set of numbers represented by @cite{b}.
  1182. If @cite{b} is an interval form, @cite{a} must be one of the values
  1183. encompassed by the interval.  If @cite{b} is a vector, @cite{a} must be
  1184. equal to one of the elements of the vector.  (If any vector elements are
  1185. intervals, @cite{a} must be in any of the intervals.)  If @cite{b} is a
  1186. plain number, @cite{a} must be numerically equal to @cite{b}.
  1187. @xref{Set Operations}, for a group of commands that manipulate sets
  1188. of this sort.
  1189. X
  1190. @tindex typeof
  1191. The @samp{typeof(a)} function produces an integer or variable which
  1192. characterizes @cite{a}.  If @cite{a} is a number, vector, or variable,
  1193. the result will be one of the following numbers:
  1194. X
  1195. @example
  1196. X 1   Integer
  1197. X 2   Fraction
  1198. X 3   Floating-point number
  1199. X 4   HMS form
  1200. X 5   Rectangular complex number
  1201. X 6   Polar complex number
  1202. X 7   Error form
  1203. X 8   Interval form
  1204. X 9   Modulo form
  1205. 10   Date-only form
  1206. 11   Date/time form
  1207. 12   Infinity (inf, uinf, or nan)
  1208. 100  Variable
  1209. 101  Vector (but not a matrix)
  1210. 102  Matrix
  1211. @end example
  1212. X
  1213. Otherwise, @cite{a} is a formula, and the result is a variable which
  1214. represents the name of the top-level function call.
  1215. X
  1216. @tindex integer
  1217. @tindex real
  1218. @tindex constant
  1219. The @samp{integer(a)} function returns true if @cite{a} is an integer.
  1220. The @samp{real(a)} function
  1221. is true if @cite{a} is a real number, either integer, fraction, or
  1222. float.  The @samp{constant(a)} function returns true if @cite{a} is
  1223. any of the objects for which @code{typeof} would produce an integer
  1224. code result except for variables, and provided that the components of
  1225. an object like a vector or error form are themselves constant.
  1226. Note that infinities do not satisfy any of these tests.@refill
  1227. X
  1228. @xref{Declarations}, for a set of similar functions that recognize
  1229. formulas as well as actual numbers.  For example, @samp{dint(floor(x))}
  1230. is true because @samp{floor(x)} is provably integer-valued, but
  1231. @samp{integer(floor(x))} does not because @samp{floor(x)} is not
  1232. literally an integer constant.
  1233. X
  1234. @tindex refers
  1235. The @samp{refers(a,b)} function is true if the variable (or sub-expression)
  1236. @cite{b} appears in @cite{a}, or false otherwise.  Unlike the other
  1237. tests described here, this function returns a definite ``no'' answer
  1238. even if its arguments are still in symbolic form.  The only case where
  1239. @code{refers} will be left unevaluated is if @cite{a} is a plain
  1240. variable (different from @cite{b}).
  1241. X
  1242. @tindex negative
  1243. The @samp{negative(a)} function returns true if @cite{a} ``looks'' negative,
  1244. because it is a negative number, because it is of the form @cite{-x},
  1245. or because it is a product or quotient with a term that looks negative.
  1246. This is most useful in rewrite rules.  Beware that @samp{negative(a)}
  1247. evaluates to 1 or 0 for @emph{any} argument @cite{a}, so it can only
  1248. be stored in a formula if the default simplifications are turned off
  1249. first with @kbd{m O}.
  1250. X
  1251. @tindex variable
  1252. The @samp{variable(a)} function is true if @cite{a} is a variable,
  1253. or false if not.  If @cite{a} is a function call, this test is left
  1254. in symbolic form.  Built-in variables like @code{pi} and @code{inf}
  1255. are considered variables like any others by this test.
  1256. X
  1257. @tindex nonvar
  1258. The @samp{nonvar(a)} function is true if @cite{a} is a non-variable.
  1259. If its argument is a variable it is left unsimplified; it never
  1260. actually returns zero.  However, since Calc's condition-testing
  1261. commands consider ``false'' anything not provably true, this is
  1262. often good enough.
  1263. X
  1264. @tindex lin
  1265. @tindex linnt
  1266. @tindex islin
  1267. @tindex islinnt
  1268. @cindex Linearity testing
  1269. The functions @code{lin}, @code{linnt}, @code{islin}, and @code{islinnt}
  1270. check if an expression is ``linear,'' i.e., can be written in the form
  1271. @cite{a + b x} for some constants @cite{a} and @cite{b}, and some
  1272. variable or subformula @cite{x}.  The function @samp{islin(f,x)} checks
  1273. if formula @cite{f} is linear in @cite{x}, returning 1 if so.  For
  1274. example, @samp{islin(x,x)}, @samp{islin(-x,x)}, @samp{islin(3,x)}, and
  1275. @samp{islin(x y / 3 - 2, x)} all return 1.  The @samp{lin(f,x)} function
  1276. is similar, except that instead of returning 1 it returns the vector
  1277. @cite{[a, b, x]}.  For the above examples, this vector would be
  1278. @cite{[0, 1, x]}, @cite{[0, -1, x]}, @cite{[3, 0, x]}, and
  1279. @cite{[-2, y/3, x]}, respectively.  Both @code{lin} and @code{islin}
  1280. generally remain unevaluated for expressions which are not linear,
  1281. e.g., @samp{lin(2 x^2, x)} and @samp{lin(sin(x), x)}.  The second
  1282. argument can also be a formula; @samp{islin(2 + 3 sin(x), sin(x))}
  1283. returns true.
  1284. X
  1285. The @code{linnt} and @code{islinnt} functions perform a similar check,
  1286. but require a ``non-trivial'' linear form, which means that the
  1287. @cite{b} coefficient must be non-zero.  For example, @samp{lin(2,x)}
  1288. returns @cite{[2, 0, x]} and @samp{lin(y,x)} returns @cite{[y, 0, x]},
  1289. SHAR_EOF
  1290. true || echo 'restore of calc.texinfo failed'
  1291. fi
  1292. echo 'End of  part 47'
  1293. echo 'File calc.texinfo is continued in part 48'
  1294. echo 48 > _shar_seq_.tmp
  1295. exit 0
  1296. exit 0 # Just in case...
  1297. -- 
  1298. Kent Landfield                   INTERNET: kent@sparky.IMD.Sterling.COM
  1299. Sterling Software, IMD           UUCP:     uunet!sparky!kent
  1300. Phone:    (402) 291-8300         FAX:      (402) 291-4362
  1301. Please send comp.sources.misc-related mail to kent@uunet.uu.net.
  1302.